home *** CD-ROM | disk | FTP | other *** search
/ IRIX Base Documentation 2002 November / SGI IRIX Base Documentation 2002 November.iso / usr / share / catman / p_man / cat3 / SCSL / intro_blas1.z / intro_blas1
Encoding:
Text File  |  2002-10-03  |  23.6 KB  |  463 lines

  1.  
  2.  
  3.  
  4. IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS1111((((3333SSSS))))                                                IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS1111((((3333SSSS))))
  5.  
  6.  
  7.  
  8. NNNNAAAAMMMMEEEE
  9.      IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS1111 - Introduction to vector-vector linear algebra subprograms
  10.  
  11. IIIIMMMMPPPPLLLLEEEEMMMMEEEENNNNTTTTAAAATTTTIIIIOOOONNNN
  12.      See individual man pages for operating system and hardware availability.
  13.  
  14. DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
  15.      The Level 1 Basic Linear Algebra Subprograms (BLAS) consist of routines
  16.      that perform vector-vector operations.  These routines are written to run
  17.      optimally on all SGI systems.
  18.  
  19.      The following data types are used in these routines:
  20.  
  21.      *   Single precision: Fortran "real" data type, C/C++ "float" data type,
  22.          32-bit floating point; these routine names begin with SSSS.
  23.  
  24.      *   Single precision complex: Fortran "complex" data type, C/C++
  25.          "scsl_complex" data type (defined in <<<<ssssccccssssllll____bbbbllllaaaassss....hhhh>>>>), C++ STL
  26.          "complex<float>" data type (defined in <<<<ccccoooommmmpppplllleeeexxxx....hhhh>), two 32-bit
  27.          floating point reals; these routine names begin with CCCC.
  28.  
  29.      *   Double precision: Fortran "double precision" data type, C/C++
  30.          "double" data type, 64-bit floating point; these routine names begin
  31.          with DDDD.
  32.  
  33.      *   Double precision complex: Fortran "double complex" data type, C/C++
  34.          "scsl_zomplex" data type (defined in <<<<ssssccccssssllll____bbbbllllaaaassss....hhhh>>>>), C++ STL
  35.          "complex<double>" data type (defined in <<<<ccccoooommmmpppplllleeeexxxx....hhhh>>>>), two 64-bit
  36.          floating point doubles; these routine names begin with ZZZZ.
  37.  
  38.      Often little or no difference exists between these versions, other than
  39.      the data types of some inputs and outputs.  In this case, the routines
  40.      are described on the same man page, and that man page is named after the
  41.      single precision or single precision complex routine.
  42.  
  43.      NOTE: SCSL supports two different C interfaces to the BLAS:
  44.  
  45.      *   The C interface described in this man page and in individual BLAS man
  46.          pages follows the same conventions used for the C interface to the
  47.          SCSL signal processing library.
  48.  
  49.      *   SCSL also supports the C interface to the legacy BLAS set forth by
  50.          the BLAS Technical Forum.  This interface supports row-major storage
  51.          of multidimensional arrays; see IIIINNNNTTTTRRRROOOO____CCCCBBBBLLLLAAAASSSS(3S) for details.
  52.  
  53.      By default, the integer arguments are 4 bytes (32 bits) in size; this is
  54.      the size obtained when one links to the SCSL library with ----llllssssccccssss or
  55.      ----llllssssccccssss____mmmmpppp. Another version of SCSL is available, however, in which
  56.      integers are 8 bytes (64 bits).  This version allows the user access to
  57.      larger memory sizes and helps when porting legacy Cray codes.  It can be
  58.      loaded by using either the ----llllssssccccssss____iiii8888 or ----llllssssccccssss____iiii8888____mmmmpppp link option.  Note
  59.      that any program may use only one of the two versions; 4-byte integer and
  60.  
  61.  
  62.  
  63.                                                                         PPPPaaaaggggeeee 1111
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70. IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS1111((((3333SSSS))))                                                IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS1111((((3333SSSS))))
  71.  
  72.  
  73.  
  74.      8-byte integer library calls cannot be mixed.
  75.  
  76.      C/C++ function prototypes for Level 1 BLAS routines are provided in
  77.      <<<<ssssccccssssllll____bbbbllllaaaassss....hhhh>>>>, when using the default 4-byte integers, and
  78.      <<<<ssssccccssssllll____bbbbllllaaaassss____iiii8888....hhhh>>>>, when using 8-byte integers. These header files define
  79.      the complex types ssssccccssssllll____ccccoooommmmpppplllleeeexxxx and ssssccccssssllll____zzzzoooommmmpppplllleeeexxxx, which are used in the
  80.      prototypes. Alternatively, C++ programs may declare arguments using the
  81.      types ccccoooommmmpppplllleeeexxxx<<<<ffffllllooooaaaatttt>>>> and ccccoooommmmpppplllleeeexxxx<<<<ddddoooouuuubbbblllleeee>>>> from the standard template
  82.      library. But if these types are used, <<<<ccccoooommmmpppplllleeeexxxx....hhhh>>>> must be included before
  83.      <<<<ssssccccssssllll____bbbbllllaaaassss....hhhh>>>> (or <<<<ssssccccssssllll____bbbbllllaaaassss____iiii8888....hhhh>>>>). Note, though, that both complex
  84.      types are equivalent: they simply represent (real, imaginary) pairs of
  85.      floating point numbers stored contiguously in memory. With the proper
  86.      casts, you can simply pass arrays of floating point data to the routines
  87.      where complex arguments are expected.
  88.  
  89.      Casts, however, can be avoided. The header files <<<<ssssccccssssllll____bbbbllllaaaassss....hhhh>>>> and
  90.      <<<<ssssccccssssllll____bbbbllllaaaassss____iiii8888....hhhh>>>> directly support the use of user-defined complex types
  91.      or disabling prototype checking for complex arguments completely.  By
  92.      defining the symbol SSSSCCCCSSSSLLLL____VVVVOOOOIIIIDDDD____AAAARRRRGGGGSSSS before including <<<<ssssccccssssllll____bbbbllllaaaassss....hhhh>>>> or
  93.      <<<<ssssccccssssllll____bbbbllllaaaassss____iiii8888....hhhh>>>> all complex arguments will be prototyped as vvvvooooiiiidddd ****.  To
  94.      define the symbol SSSSCCCCSSSSLLLL____VVVVOOOOIIIIDDDD____AAAARRRRGGGGSSSS at compile time use the ----DDDD compiler
  95.      option (i.e., ----DDDDSSSSCCCCSSSSLLLL____VVVVOOOOIIIIDDDD____AAAARRRRGGGGSSSS) or use an explicit ####ddddeeeeffffiiiinnnneeee SSSSCCCCSSSSLLLL____VVVVOOOOIIIIDDDD____AAAARRRRGGGGSSSS
  96.      in the source code.  This allows the use of any complex data structure
  97.      without warnings from the compiler, provided the structure is as
  98.      described above; that is:
  99.  
  100.      1.   The real and imaginary components must be contiguous in memory.
  101.  
  102.      2.   Sequential array elements must also be contiguous in memory.
  103.  
  104.      While this allows the use of non-standard complex types without
  105.      generating compiler warnings, it has the disadvantage that the compiler
  106.      will not catch type mismatches.
  107.  
  108.      Strong type checking can be enabled employing user-defined complex types
  109.      instead of SCSL's standard complex types. To do this, define
  110.      SSSSCCCCSSSSLLLL____UUUUSSSSEEEERRRR____CCCCOOOOMMMMPPPPLLLLEEEEXXXX____TTTT====_m_y__c_o_m_p_l_e_x and SSSSCCCCSSSSLLLL____UUUUSSSSEEEERRRR____ZZZZOOOOMMMMPPPPLLLLEEEEXXXX____TTTT====_m_y__z_o_m_p_l_e_x, where
  111.      _m_y__c_o_m_p_l_e_x and _m_y__z_o_m_p_l_e_x are the names of user-defined complex types.
  112.      These complex types must be defined before including the <<<<ssssccccssssllll____bbbbllllaaaassss....hhhh>>>>
  113.      (or <<<<ssssccccssssllll____bbbbllllaaaassss____iiii8888....hhhh>>>>) header file.
  114.  
  115.      Fortran 90 users on IRIX systems can perform compile-time checking of
  116.      SCSL BLAS subroutine and function calls by adding UUUUSSSSEEEE SSSSCCCCSSSSLLLL____BBBBLLLLAAAASSSS (for 4-
  117.      byte integer arguments) or UUUUSSSSEEEE SSSSCCCCSSSSLLLL____BBBBLLLLAAAASSSS____IIII8888 (for 8-byte integer
  118.      arguments) to the source code from which the BLAS calls are made.
  119.      Alternatively, the compile-time checking can be invoked without any
  120.      source code modifications by using the ----aaaauuuuttttoooo____uuuusssseeee compiler option, e.g.,
  121.  
  122.           f90 -auto_use SCSL_BLAS test.f -lscs
  123.           f90 -auto_use SCSL_BLAS_I8 -i8 test.f -lscs_i8
  124.  
  125.  
  126.  
  127.  
  128.  
  129.                                                                         PPPPaaaaggggeeee 2222
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136. IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS1111((((3333SSSS))))                                                IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS1111((((3333SSSS))))
  137.  
  138.  
  139.  
  140.    LLLLeeeevvvveeeellll 1111 BBBBaaaassssiiiicccc LLLLiiiinnnneeeeaaaarrrr AAAAllllggggeeeebbbbrrrraaaa SSSSuuuubbbbpppprrrrooooggggrrrraaaammmmssss
  141.      The Level 1 BLAS perform basic vector-vector operations.
  142.  
  143.      The following three types of vector-vector operations are available:
  144.  
  145.      *   Dot products and various vector norms
  146.  
  147.      *   Scaling, copying, swapping, and computing linear combination of
  148.          vectors
  149.  
  150.      *   Generating or applying plane or modified plane rotations.
  151.  
  152.    IIIInnnnccccrrrreeeemmmmeeeennnntttt aaaarrrrgggguuuummmmeeeennnnttttssss
  153.      A vector's description consists of the name of the array (_x or _y)
  154.      followed by the storage spacing (increment) in the array of vector
  155.      elements (_i_n_c_x or _i_n_c_y).  The increment can be positive or negative.
  156.      When a vector _x consists of _n elements, the corresponding actual array
  157.      arguments must be of a length at least 1111++++((((nnnn----1111))))****||||iiiinnnnccccxxxx||||.  For a negative
  158.      increment, the first element of _x is assumed to be xxxx((((1111++++((((nnnn----1111))))****||||iiiinnnnccccxxxx||||)))) for
  159.      Fortran arrays, xxxx[[[[((((nnnn----1111))))****||||iiiinnnnccccxxxx||||]]]] for C/C++ arrays.  The standard
  160.      specification of ____SSSSCCCCAAAALLLL, ____NNNNRRRRMMMM2222, ____AAAASSSSUUUUMMMM, and IIII____AAAAMMMMAAAAXXXX does not define their
  161.      behavior for negative increments, so this functionality is an extension
  162.      to the standard BLAS.
  163.  
  164.      Setting an increment argument to 0 can cause unpredictable results.
  165.  
  166.    MMMMaaaannnn ppppaaaaggggeeee nnnnaaaammmmiiiinnnngggg
  167.      The mmmmaaaannnn(1) command can find a man page online by either the single
  168.      precision, single precision complex, double precision, or double
  169.      precision complex name.
  170.  
  171.      The following table describes the naming conventions for these routines:
  172.  
  173.      -------------------------------------------------------------
  174.                                             Single        Double
  175.                  Single        Double       Precision     Precision
  176.                  Precision     Precision    Complex       Complex
  177.      -------------------------------------------------------------
  178.      form:       Sname         Dname        Cname         Zname
  179.      example:    SGEMM         DGEMM        CGEMM         ZGEMM
  180.      -------------------------------------------------------------
  181.  
  182.  
  183.    FFFFoooorrrrttttrrrraaaannnn ttttyyyyppppeeee ddddeeeeccccllllaaaarrrraaaattttiiiioooonnnn ffffoooorrrr ffffuuuunnnnccccttttiiiioooonnnnssss
  184.      Always declare the data type of external functions.  Declaring the data
  185.      type of the complex Level 1 BLAS functions is particularily important
  186.      because, based on the first letter of their names and the Fortran data
  187.      typing rules, the default implied data type would be REAL.
  188.  
  189.      Fortran type declarations for function names follow:
  190.  
  191.  
  192.  
  193.  
  194.  
  195.                                                                         PPPPaaaaggggeeee 3333
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202. IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS1111((((3333SSSS))))                                                IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS1111((((3333SSSS))))
  203.  
  204.  
  205.  
  206.      TTTTyyyyppppeeee                  FFFFuuuunnnnccccttttiiiioooonnnn NNNNaaaammmmeeee
  207.  
  208.      RRRREEEEAAAALLLL                  SSSSAAAASSSSUUUUMMMM, SSSSCCCCAAAASSSSUUUUMMMM, SSSSCCCCNNNNRRRRMMMM2222, SSSSDDDDOOOOTTTT, SSSSNNNNRRRRMMMM2222, SSSSSSSSUUUUMMMM
  209.  
  210.      CCCCOOOOMMMMPPPPLLLLEEEEXXXX               CCCCDDDDOOOOTTTTCCCC, CCCCDDDDOOOOTTTTUUUU, CCCCSSSSUUUUMMMM
  211.  
  212.      DDDDOOOOUUUUBBBBLLLLEEEE PPPPRRRREEEECCCCIIIISSSSIIIIOOOONNNN      DDDDAAAASSSSUUUUMMMM, DDDDZZZZAAAASSSSUUUUMMMM, DDDDDDDDOOOOTTTT, DDDDNNNNRRRRMMMM2222, DDDDZZZZNNNNRRRRMMMM2222, DDDDSSSSUUUUMMMM
  213.  
  214.      DDDDOOOOUUUUBBBBLLLLEEEE CCCCOOOOMMMMPPPPLLLLEEEEXXXX        ZZZZDDDDOOOOTTTTCCCC, ZZZZDDDDOOOOTTTTUUUU, ZZZZSSSSUUUUMMMM
  215.  
  216.      IIIINNNNTTTTEEEEGGGGEEEERRRR               IIIISSSSAAAAMMMMAAAAXXXX, IIIIDDDDAAAAMMMMAAAAXXXX, IIIICCCCAAAAMMMMAAAAXXXX, IIIIZZZZAAAAMMMMAAAAXXXX, IIIISSSSAAAAMMMMIIIINNNN, IIIIDDDDAAAAMMMMIIIINNNN,
  217.                            IIIISSSSMMMMAAAAXXXX, IIIIDDDDMMMMAAAAXXXX, IIIISSSSMMMMIIIINNNN, IIIIDDDDMMMMIIIINNNN
  218.  
  219.    LLLLeeeevvvveeeellll 1111 BBBBLLLLAAAASSSS sssseeeeaaaarrrrcccchhhh ffffuuuunnnnccccttttiiiioooonnnnssss
  220.      Several search functions are a part of Level 1 BLAS; these functions are
  221.      listed below (functions marked with an asterisk [*] are extensions to the
  222.      standard set of Level 1 BLAS routines):
  223.  
  224.      IIIISSSSAAAAMMMMAAAAXXXX,,,, IIIICCCCAAAAMMMMAAAAXXXX,,,, IIIISSSSAAAAMMMMIIIINNNN****,,,, IIIISSSSMMMMAAAAXXXX****,,,, IIIISSSSMMMMIIIINNNN****
  225.      IIIIDDDDAAAAMMMMAAAAXXXX  IIIIZZZZAAAAMMMMAAAAXXXX,,,, IIIIDDDDAAAAMMMMIIIINNNN*, IIIIDDDDMMMMAAAAXXXX*, IIIIDDDDMMMMIIIINNNN*
  226.  
  227.  
  228.    LLLLiiiisssstttt ooooffff LLLLeeeevvvveeeellll 1111 BBBBLLLLAAAASSSS rrrroooouuuuttttiiiinnnneeeessss
  229.      The following list contains the purpose, operation, and name of each
  230.      Level 1 BLAS routine.  The routines marked with an asterisk (*) are
  231.      extensions to the standard set of Level 1 BLAS routines.  For complete
  232.      details about each operation, see the individual man pages.
  233.  
  234.      *   SSSSAAAASSSSUUUUMMMM, DDDDAAAASSSSUUUUMMMM:  Sums the absolute values of the elements of a real
  235.          vector (also called the l norm).
  236.  
  237.                                  n
  238.               sasum <- ||x||  = Sum |x |
  239.                             1   i=1   i
  240.  
  241.  
  242.      *   SSSSCCCCAAAASSSSUUUUMMMM, DDDDZZZZAAAASSSSUUUUMMMM: Sums the absolute values of the real and imaginary
  243.          parts of the elements of a complex vector, as follows:
  244.  
  245.               scasum <- ||Real[x]||  + ||Imag[x]||  =
  246.                                    1              1
  247.  
  248.                  n                n
  249.                 Sum |Real[x ]| + Sum |Imag[x ]|
  250.                 i=1        i     i=1        i
  251.  
  252.  
  253.      *   SSSSAAAAXXXXPPPPBBBBYYYY*, DDDDAAAAXXXXPPPPBBBBYYYY*, CCCCAAAAXXXXPPPPBBBBYYYY*, ZZZZAAAAXXXXPPPPBBBBYYYY*:  Adds a scalar multiple of a real
  254.          or complex vector to a scalar multiple of another vector.
  255.  
  256.               y <- alpha x + beta y
  257.  
  258.  
  259.  
  260.  
  261.                                                                         PPPPaaaaggggeeee 4444
  262.  
  263.  
  264.  
  265.  
  266.  
  267.  
  268. IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS1111((((3333SSSS))))                                                IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS1111((((3333SSSS))))
  269.  
  270.  
  271.  
  272.      *   SSSSAAAAXXXXPPPPYYYY, DDDDAAAAXXXXPPPPYYYY, CCCCAAAAXXXXPPPPYYYY, ZZZZAAAAXXXXPPPPYYYY:  Adds a scalar multiple of a real or
  273.          complex vector to another vector.
  274.  
  275.               y <- alpha x + y
  276.  
  277.  
  278.      *   SSSSCCCCOOOOPPPPYYYY, DDDDCCCCOOOOPPPPYYYY, CCCCCCCCOOOOPPPPYYYY, ZZZZCCCCOOOOPPPPYYYY:  Copies a real or complex vector into
  279.          another vector.
  280.  
  281.               y <- x
  282.  
  283.  
  284.      *   SSSSDDDDOOOOTTTT, DDDDDDDDOOOOTTTT, CCCCDDDDOOOOTTTTUUUU, ZZZZDDDDOOOOTTTTUUUU:  Computes a dot product of two real or
  285.          complex vectors.
  286.  
  287.                        T      n
  288.               sdot <- x y  = Sum  x y
  289.                              i=1   i i
  290.  
  291.  
  292.      *   CCCCDDDDOOOOTTTTCCCC, ZZZZDDDDOOOOTTTTCCCC: Computes a dot product of the conjugate of a complex
  293.          vector and another complex vector.
  294.  
  295.                         H     n  _
  296.               cdotc <- x y = Sum x y
  297.                              i=1  i i
  298.  
  299.  
  300.      *   SSSSHHHHAAAADDDD*, DDDDHHHHAAAADDDD*, CCCCHHHHAAAADDDD*, ZZZZHHHHAAAADDDD*:  Computes the Hadamard product of two
  301.          vectors.
  302.  
  303.               z  <- alpha x y  + beta z
  304.                i           i i         i
  305.  
  306.  
  307.      *   SSSSNNNNRRRRMMMM2222, DDDDNNNNRRRRMMMM2222:  Computes the Euclidean norm (also called l norm) of a
  308.          real vector.
  309.  
  310.                                        n   2
  311.               snrm2 <- ||x||   = sqrt(Sum x )
  312.                             2         i=1  i
  313.  
  314.  
  315.  
  316.      *   SSSSCCCCNNNNRRRRMMMM2222, DDDDZZZZNNNNRRRRMMMM2222: Computes the Euclidean norm (1 norm) of a complex
  317.          vector.
  318.  
  319.                                        n   _
  320.               scnrm2 <- ||x||  = sqrt(Sum (x  x )
  321.                              2        i=1   1  1
  322.  
  323.  
  324.  
  325.  
  326.  
  327.                                                                         PPPPaaaaggggeeee 5555
  328.  
  329.  
  330.  
  331.  
  332.  
  333.  
  334. IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS1111((((3333SSSS))))                                                IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS1111((((3333SSSS))))
  335.  
  336.  
  337.  
  338.      *   CCCCSSSSRRRROOOOTTTT*, ZZZZDDDDRRRROOOOTTTT*, CCCCRRRROOOOTTTT****, ZZZZRRRROOOOTTTT****:  Applies a real plane rotation to a
  339.          pair of complex vectors.
  340.  
  341.      *   SSSSRRRROOOOTTTT, DDDDRRRROOOOTTTT:  Applies an orthogonal plane rotation.
  342.  
  343.      *   SSSSRRRROOOOTTTTGGGG, DDDDRRRROOOOTTTTGGGG, CCCCRRRROOOOTTTTGGGG*, ZZZZRRRROOOOTTTTGGGG*: Constructs a Givens plane rotation.
  344.  
  345.      *   SSSSRRRROOOOTTTTMMMM, DDDDRRRROOOOTTTTMMMM:  Applies a modified Givens plane rotation.
  346.  
  347.      *   SSSSRRRROOOOTTTTMMMMGGGG ,DDDDRRRROOOOTTTTMMMMGGGG: Constructs a modified Givens plane rotation.
  348.  
  349.      *   SSSSSSSSCCCCAAAALLLL, DDDDSSSSCCCCAAAALLLL, CCCCSSSSCCCCAAAALLLL, ZZZZSSSSCCCCAAAALLLL, CCCCSSSSSSSSCCCCAAAALLLL, ZZZZDDDDSSSSCCCCAAAALLLL:  Scales a real or complex
  350.          vector.
  351.  
  352.               x <- alpha x
  353.  
  354.  
  355.      *   SSSSSSSSUUUUMMMM*, DDDDSSSSUUUUMMMM*, CCCCSSSSUUUUMMMM*, ZZZZSSSSUUUUMMMM*:  Sums the elements of a real or complex
  356.          vector.
  357.  
  358.                       n
  359.               sum <- Sum x
  360.                      i=1  i
  361.  
  362.  
  363.      *   SSSSSSSSWWWWAAAAPPPP, DDDDSSSSWWWWAAAAPPPP, CCCCSSSSWWWWAAAAPPPP, ZZZZSSSSWWWWAAAAPPPP:  Swaps two real or two complex vectors.
  364.  
  365.               x <-> y
  366.  
  367.  
  368.      *   IIIISSSSAAAAMMMMAAAAXXXX, IIIIDDDDAAAAMMMMAAAAXXXX, IIIICCCCAAAAMMMMAAAAXXXX, IIIIZZZZAAAAMMMMAAAAXXXX:  Searches a vector for the first
  369.          occurrence of the maximum absolute value.
  370.  
  371.               isamax <- MAX |x |
  372.                               j
  373.  
  374.  
  375.      *   IIIISSSSAAAAMMMMIIIINNNN*, IIIIDDDDAAAAMMMMIIIINNNN*:  Searches a vector for the first occurrence of the
  376.          minimum absolute value.
  377.  
  378.               isamin <- MIN |x |
  379.                               j
  380.  
  381.  
  382.      *   IIIISSSSMMMMAAAAXXXX*, IIIIDDDDMMMMAAAAXXXX*:  Searches a vector for the first occurrence of the
  383.          maximum value.
  384.  
  385.               ismax <- MAX x
  386.                             j
  387.  
  388.  
  389.  
  390.  
  391.  
  392.  
  393.                                                                         PPPPaaaaggggeeee 6666
  394.  
  395.  
  396.  
  397.  
  398.  
  399.  
  400. IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS1111((((3333SSSS))))                                                IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS1111((((3333SSSS))))
  401.  
  402.  
  403.  
  404.      *   IIIISSSSMMMMIIIINNNN*, IIIIDDDDMMMMIIIINNNN*:  Searches a vector for the first occurrence of the
  405.          minimum value.
  406.  
  407.               ismin <- MIN x
  408.                             j
  409.  
  410.  
  411. NNNNOOOOTTTTEEEESSSS
  412.      SCSL does not currently support reshaped arrays.
  413.  
  414. SSSSEEEEEEEE AAAALLLLSSSSOOOO
  415.      Lawson, C., Hanson, R., Kincaid, D., and Krogh, F., "Basic Linear Algebra
  416.      Subprograms for Fortran Usage," _A_C_M _T_r_a_n_s_a_c_t_i_o_n_s _o_n _M_a_t_h_e_m_a_t_i_c_a_l
  417.      _S_o_f_t_w_a_r_e, 5 (1979), pp. 308 - 325.
  418.  
  419.      IIIINNNNTTTTRRRROOOO____SSSSCCCCSSSSLLLL(3S), IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS2222(3S), IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS3333(3S), IIIINNNNTTTTRRRROOOO____CCCCBBBBLLLLAAAASSSS(3S)
  420.  
  421.  
  422.  
  423.  
  424.  
  425.  
  426.  
  427.  
  428.  
  429.  
  430.  
  431.  
  432.  
  433.  
  434.  
  435.  
  436.  
  437.  
  438.  
  439.  
  440.  
  441.  
  442.  
  443.  
  444.  
  445.  
  446.  
  447.  
  448.  
  449.  
  450.  
  451.  
  452.  
  453.  
  454.  
  455.  
  456.                                                                         PPPPaaaaggggeeee 7777
  457.  
  458.  
  459.  
  460.  
  461.  
  462.  
  463.